/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */




package br.com.eurotrader.views;

import br.com.eurotrader.consulta.ConsultaSimplesBean;
import br.com.eurotrader.consulta.Criterio;
import br.com.eurotrader.controller.BaseController;
import br.com.eurotrader.dao.BaseDao;
import br.com.eurotrader.interfaces.InterfaceEntidades;
import br.com.eurotrader.navegacao.NavegarPorPaginas;
import br.com.eurotrader.utils.FacesUtils;
import br.com.eurotrader.utils.MetodosBotoes;
import com.icesoft.faces.component.ext.HtmlDataTable;
import com.icesoft.faces.component.ext.HtmlInputText;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.DateTimeConverter;
import javax.faces.convert.NumberConverter;
import javax.faces.event.ActionEvent;
import javax.faces.event.ValueChangeEvent;
import javax.faces.model.ArrayDataModel;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.model.SelectItem;

/**
 *
 * @author Edmilson
 */
public class beanViewPadrao<T, ID> {
    
    private BaseDao<T, ID> objetoDao;

    public BaseDao<T, ID> getObjetoDao() {
        return objetoDao;
    }
    private T objeto;

    public T getObjeto() {
        return objeto;
    }   

    public void setColunasTabela(String coluna, String relacao) {
        listaDeColunas.add(coluna);
        relacoes.put(coluna, relacao);
    }
    private List<String> listaDeColunas = new ArrayList<String>();
    private HashMap relacoes = new HashMap();

    public HashMap getRelacoes() {
        return relacoes;
    }

    public void setRelacoes(HashMap relacoes) {
        this.relacoes = relacoes;
    }

    public List getListaDeColunas() {
        return listaDeColunas;
    }

    public void setObjeto(T objeto) {
        this.objeto = objeto;
    }

    public void setObjetoDao(BaseDao<T, ID> objetoDao) {
        this.objetoDao = objetoDao;
    }

    public void atualizar(ActionEvent event) {
//        if (metodoValidarCampos(event)) {
        try {
            if (validacoes(event)) {
                objetoDao.update((T) objeto);
                gravaLog("alteração", (InterfaceEntidades) objeto, 0);
                desabitarFormulario();
                limparSqlsConsulta();
                atualizaTabela();
                renderizar();
                metodoDepoisDoSalvarAtualizar();
                verificaPaginaAnterior();
            }
        } catch (Exception e) {
            FacesUtils.addErrorMessage("Um erro ocorreu na atualização do registro. Informe ao administrados o sistema o seguinte erro: " + e.toString());
            e.printStackTrace();
        }
//        }
    }

    public void metodoDepoisDoSalvarAtualizar() {
    }

    public void salvar(ActionEvent event) {
//        if (((MetodosBotoes) FacesUtils.getManagedBean("botoes")).metodoValidarCampos(event)) {
        try {
            if (validacoes(event)) {

//                acrescentaCodigo(objeto);
//                acrescentaFilial(objeto);

                objetoDao.save((T) objeto);
                gravaLog("inclusão", (InterfaceEntidades) objeto, 0);
                // objetoLimpo();
                desabitarFormulario();
                limparSqlsConsulta();
                atualizaTabela();
                //  limpaLinhasTabela();
                renderizar();
                paginaAtual = 0;
                metodoDepoisDoSalvarAtualizar();
                verificaPaginaAnterior();
            }
//        }
        } catch (Exception e) {
            FacesUtils.addErrorMessage("Um erro ocorreu na gravação do registro. Informe ao administrados o sistema o seguinte erro: " + e.toString());
            e.printStackTrace();
        }
    }

    private void verificaPaginaAnterior() {
        ((NavegarPorPaginas) FacesUtils.getManagedBean("navegaEntrePaginas")).voltarPagina();
    }

    private void habilitarFormulario() {
        setFormularioDesabilitado(false);
        imediato = true;
    }

    private void desabitarFormulario() {
        setFormularioDesabilitado(true);
        imediato = false;
    }

    private void renderizar() {
    }

    public void excluir(ActionEvent event) {
        Integer id = ((InterfaceEntidades) objeto).getId();
        Integer codigo = 0;
        try {
            objetoDao.delete((T) objeto);
            objetoLimpo();
            ((InterfaceEntidades) objeto).setId(id);
            gravaLog("exclusão", ((InterfaceEntidades) objeto), codigo);
            objetoLimpo();
            desabitarFormulario();
            limparSqlsConsulta();
            atualizaTabela();
            ((MetodosBotoes) FacesUtils.getManagedBean("botoes")).metodoLimparDoCancelar(event);
            //  limpaLinhasTabela();
            renderizar();
        } catch (Exception e) {
            FacesUtils.addInfoMessage("Não foi possível excluír. O registro não pode ser excluído por um erro interno ou por ser referênciado por um outro registro.");
            System.out.println("Erro ao excluir " + e.getMessage());
            e.printStackTrace();
        }
    }

    public List todos() {
        return objetoDao.getAll();
    }

    public List pesquisar(String sql) {
        return objetoDao.pesq(sql, "");
    }

    public T buscarPorChave(Object chave) {
        return (T) objetoDao.getByID((ID) chave);
    }

    public void objetoLimpo() {
        try {
            objeto = (T) objeto.getClass().newInstance();
        } catch (InstantiationException ex) {
            Logger.getLogger(BaseController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(BaseController.class.getName()).log(Level.SEVERE, null, ex);
        }
        //  return null;
    }

    public InterfaceEntidades objetoPreenchido(Object data) {
        return (InterfaceEntidades) data;
    }

    public void limparSqlsConsulta() {
        sqlConsulta = null;
        sqlClausulaTodosRegistros = null;
    }

    public void atualizaTabela() {
        if ((sqlConsulta != null) && (sqlClausulaTodosRegistros != null)
                && (!sqlConsulta.isEmpty()) && (!sqlClausulaTodosRegistros.isEmpty())) {
            rowModel = new ListDataModel(objetoDao.todosRegistrosPag(maxPorPagina, paginaAtual, sqlConsulta));
            totalDeRegistros = objetoDao.getTotalDeRegistros(sqlClausulaTodosRegistros);
        } else {
            totalDeRegistros = objetoDao.getTotalDeRegistros();
            rowModel = new ListDataModel(objetoDao.todosRegistrosPaginados(maxPorPagina, paginaAtual));
        }
    }
    
    private String sqlConsulta = null;
    private String sqlClausulaTodosRegistros = null;

    public String getSqlClausulaTodosRegistros() {
        return sqlClausulaTodosRegistros;
    }

    public void setSqlClausulaTodosRegistros(String clausulaTodosRegistros) {
        this.sqlClausulaTodosRegistros = clausulaTodosRegistros;
    }

    public String getSqlConsulta() {
        return sqlConsulta;
    }

    public void setSqlConsulta(String sqlConsulta) {
        this.sqlConsulta = sqlConsulta;
    }

    private DataModel columnsModel = null;

    public DataModel getColumnsModel() {
        columnsModel = new ArrayDataModel(getListaDeColunas().toArray());
        return columnsModel;
    }

    public DataModel getRowModel() {
        if (rowModel == null) {
            limparSqlsConsulta();
            atualizaTabela();
        } 
        return rowModel;
    }
    
    private DataModel rowModel = null;

    public void setRowModel(DataModel rowModel) {
        this.rowModel = rowModel;
    }

    public void setColumnsModel(DataModel columnsModel) {
        this.columnsModel = columnsModel;
    }

    public Object getDadosLinhas(int col, DataModel rowModel) {
        return null;
    }

    public Object getCellValue() {
        if (rowModel != null && columnsModel != null) {
            if (rowModel.isRowAvailable() && columnsModel.isRowAvailable()) {
                return getDadosLinhas(columnsModel.getRowIndex(), rowModel);
            } //   System.out.println("retornando null");
        }
        return null;
    }
    public int maxPorPagina = 9;
    public int paginaAtual = 0;
    public Long totalDeRegistros;

    public Long getTotalDeRegistros() {
        return totalDeRegistros;
    }

    public void setTotalDeRegistros(Long totalDeRegistros) {
        this.totalDeRegistros = totalDeRegistros;
    }

    public int getPaginaAtual() {
        return paginaAtual;
    }

    public void setPaginaAtual(int paginaAtual) {
        this.paginaAtual = paginaAtual;
    }

    public String primeiraPagina() {
        paginaAtual = 0;
        atualizaTabela();
        return null;
    }

    public String ultimaPagina() {
        Long rest = (getTotal() % maxPorPagina);
        if (rest != 0) {
            paginaAtual = (int) (getTotal() - rest);
        } else {
            paginaAtual = (int) (getTotal() - maxPorPagina);
        }
        atualizaTabela();
        return null;
    }

    public String proxima() {
        int soma = paginaAtual + maxPorPagina;
        if (soma < getTotal()) {
            paginaAtual += maxPorPagina;
        }
        atualizaTabela();
        return null;
    }

    public String anterior() {
        paginaAtual -= maxPorPagina;
        if (paginaAtual < 0) {
            paginaAtual = 0;
        }
        setPaginaAtual(paginaAtual);
        atualizaTabela();
        return null;
    }

    public Long getProximaPagina() {
        Long total = getTotal();
        int soma = getPaginaAtual() + maxPorPagina;
        Long proxima = (soma > total) ? total : soma;
        return proxima;
    }

    public Long getTotal() {
        return totalDeRegistros;
    }

    public Boolean validacoes(ActionEvent event) {
        return true;
    }

    public void botaoAlterarTabela(ActionEvent event) {
        setObjeto((T) getRowModel().getRowData());
        visualizar(event);
    }

    public void alterar(ActionEvent click) {
        editar(click);
    }
    
    private Boolean flagPanelConsulta = false;
    private Boolean flagPanelFormulario = true;

    public Boolean getFlagPanelConsulta() {
        return flagPanelConsulta;
    }

    public void setFlagPanelConsulta(Boolean flagPanelConsulta) {
        this.flagPanelConsulta = flagPanelConsulta;
    }

    public Boolean getFlagPanelFormulario() {
        return flagPanelFormulario;
    }

    public void setFlagPanelFormulario(Boolean flagPanelFormulario) {
        this.flagPanelFormulario = flagPanelFormulario;
    }

    public void trocaPainel(ActionEvent event) {

        if (getFlagPanelFormulario()) {
            setFlagPanelConsulta(true);
            setFlagPanelFormulario(false);
        } else {
            setFlagPanelConsulta(false);
            setFlagPanelFormulario(true);
            visualizandoORegistro();
        }
        if (!formularioDesabilitado) {
            cancelar(null);
        }
    }

    public void trocaPainel1(ActionEvent event) {
        if (getFlagPanelConsulta()) {
            setFlagPanelConsulta(false);
            setFlagPanelFormulario(true);
            visualizandoORegistro();
        } else {
            setFlagPanelConsulta(true);
            setFlagPanelFormulario(false);
        }

        if (!formularioDesabilitado) {
            cancelar(null);
        }

    }

    public void editar(ActionEvent event) {
        if ((getObjeto() != null) && ((InterfaceEntidades) getObjeto()).getId() != null) {
            habilitarFormulario();
            inputText.requestFocus();
        }
    }

    public void visualizar(ActionEvent event) {
        setFlagPanelConsulta(Boolean.FALSE);
        setFlagPanelFormulario(Boolean.TRUE);
        visualizandoORegistro();
    }
    
    private HtmlInputText inputText = new HtmlInputText();
    private HtmlDataTable dataTable1 = new HtmlDataTable();

    public HtmlDataTable getDataTable1() {
        return dataTable1;
    }

    public void setDataTable1(HtmlDataTable dataTable1) {
        this.dataTable1 = dataTable1;
    }

    public HtmlInputText getInputText() {
        return inputText;
    }

    public void setInputText(HtmlInputText inputText) {
        this.inputText = inputText;
    }
    private boolean formularioDesabilitado = true;

    public boolean isFormularioDesabilitado() {
        return formularioDesabilitado;
    }

    public void setFormularioDesabilitado(boolean formularioDesabilitado) {
        this.formularioDesabilitado = formularioDesabilitado;
    }

    public void inserir(ActionEvent event) {
        objetoLimpo();
        habilitarFormulario();
        getInputText().requestFocus();
        visualizandoORegistro();
    }

    public void cancelar(ActionEvent event) {
        desabitarFormulario();
        if (((InterfaceEntidades) getObjeto()).getId() != null) {
            setObjeto(objetoDao.getByID((ID) ((InterfaceEntidades) getObjeto()).getId()));
        } else {
            objetoLimpo();
        }
        atualizaTabela();
        limparSqlsConsulta();
        ((MetodosBotoes) FacesUtils.getManagedBean("botoes")).metodoLimparDoCancelar(event);
        verificaPaginaAnterior();
    }

    public void salvarRegistro(ActionEvent event) {
        if (((InterfaceEntidades) objeto).getId() != null) {
            atualizar(event);
        } else {
            salvar(event);
        }
    }

    public void recarregarTabela(ActionEvent event) {
        paginaAtual = 0;
        limparSqlsConsulta();
        atualizaTabela();
    }

    public List<SelectItem> getColunas() {
        List<SelectItem> items = new ArrayList<SelectItem>();
        for (int i = 0; i < getListaDeColunas().size(); i++) {
            items.add(new SelectItem(getListaDeColunas().get(i)));
        }
        return items;
    }

    public List<SelectItem> getOperadores() {
        List<SelectItem> items = new ArrayList<SelectItem>();
        items.add(new SelectItem("contendo"));
        items.add(new SelectItem("igual a"));
        items.add(new SelectItem("diferente de"));
        items.add(new SelectItem("iniciando com"));
        items.add(new SelectItem("terminando com"));
        items.add(new SelectItem("maior que"));
        items.add(new SelectItem("menor que"));
        items.add(new SelectItem("maior ou igual"));
        items.add(new SelectItem("menor ou igual"));
        items.add(new SelectItem("data igual a"));
        items.add(new SelectItem("data menor que"));
        items.add(new SelectItem("data maior que"));
        items.add(new SelectItem("data maior ou igual"));
        items.add(new SelectItem("data menor ou igual"));
        items.add(new SelectItem("hora igual a"));
        items.add(new SelectItem("hora maior que"));
        items.add(new SelectItem("hora menor que"));
        items.add(new SelectItem("hora maior ou igual"));
        items.add(new SelectItem("hora menor ou igual"));
        return items;
    }

    public List<SelectItem> getConcatenadores() {
        List<SelectItem> items = new ArrayList<SelectItem>();
        items.add(new SelectItem("e"));
        items.add(new SelectItem("ou"));
        return items;
    }

    public void abrirPagina() {
        paginaAtual = 0;
        objetoLimpo();
        desabitarFormulario();
        setFlagPanelConsulta(Boolean.FALSE);
        setFlagPanelFormulario(Boolean.TRUE);
        limparSqlsConsulta();
        atualizaTabela();
        ConsultaSimplesBean consultaSimplesBean = (ConsultaSimplesBean) FacesUtils.getManagedBean("consultaSimples");
        consultaSimplesBean.setItTexto("");
        consultaSimplesBean.setSomOperador(getOperadores().get(0) + "");
        consultaSimplesBean.setSomCampo(getColunas().get(0) + "");
        visualizandoORegistro();
    }
    private boolean imediato = false;

    public boolean isImediato() {
        return imediato;
    }

    public void setImediato(boolean imediato) {
        this.imediato = imediato;
    }

    public T buscaPorCampo(String campo, String texto) {
        return (T) objetoDao.getPorCampo(campo, texto);
    }

    public void visualizandoORegistro() {
    }

    public Boolean encontrouRegistro(String sql) {
        return objetoDao.encontrouRegistro(sql);
    }

    public T getResultadoSimples(String sql) {
        return objetoDao.getResultadoSimples(sql);
    }

    public void gravaLog(String operacao, InterfaceEntidades interfaceEntidades, Integer codigo) {
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////
    private String somCampo = new String();

    public String getSomCampo() {
        return somCampo;
    }

    public void setSomCampo(String somCampo) {
        this.somCampo = somCampo;
    }
    private String somOperador = new String();

    public String getSomOperador() {
        return somOperador;
    }

    public void setSomOperador(String somOperador) {
        this.somOperador = somOperador;
    }
    private String itTexto = "";

    public String getItTexto() {
        return itTexto;
    }

    public void setItTexto(String itTexto) {
        this.itTexto = itTexto;
    }
    private Converter conversor;

    public Converter getConversor() {
        return conversor;
    }

    public void setConversor(Converter conversor) {
        this.conversor = conversor;
    }

    public void consultar(ActionEvent event) {
        if ((itTexto == null) || (itTexto.trim().equals(""))) {
            return;
        }

        String textoConvertido = itTexto.toString().replace("'", "''");
        Criterio criterio = new Criterio(getSomCampo(), getSomOperador(), textoConvertido);
        String sql = "";
        String nomeClasse;
        String nomeDaPagina = FacesContext.getCurrentInstance().getViewRoot().getViewId().toString();
        if (nomeDaPagina.toUpperCase().equals("LOG DE OPERAÇÕES")) {
            nomeClasse = "LogOperacoes";
        } else {
            nomeClasse = getObjeto().getClass().getSimpleName();
        }
        String tabelas = "";

        String campo = (String) getRelacoes().get(criterio.getColuna());
        if (campo.indexOf("/") != -1) {
            tabelas = campo.substring(0, campo.indexOf("/"));
            campo = campo.substring(campo.indexOf("/") + 1, campo.length());
        }
        sql = "SELECT DISTINCT c FROM " + nomeClasse + " c " + tabelas + " WHERE (";
        campo = campo.substring(0, 1).toLowerCase().concat(campo.substring(1));
        sql += ("upper(c." + campo + ")");  //+ campo + ")");

        if (criterio.getOperador().toLowerCase().trim().equals("igual a")) {
            sql = sql + " = upper('" + criterio.getTexto() + "')";
        } else if (criterio.getOperador().toLowerCase().trim().equals("maior que")) {
            sql = sql + " > " + criterio.getTexto();
        } else if (criterio.getOperador().toLowerCase().trim().equals("menor que")) {
            sql = sql + " < " + criterio.getTexto();
        } else if (criterio.getOperador().toLowerCase().trim().equals("maior ou igual")) {
            sql = sql + " >= " + criterio.getTexto();
        } else if (criterio.getOperador().toLowerCase().trim().equals("menor ou igual")) {
            sql = sql + " <= " + criterio.getTexto();
        } else if ((criterio.getOperador().toLowerCase().trim().equals("data igual a"))
                || (criterio.getOperador().toLowerCase().trim().equals("hora igual a"))) {
            sql = sql + " = '" + criterio.getTexto() + "'";
        } else if ((criterio.getOperador().toLowerCase().trim().equals("data menor que"))
                || (criterio.getOperador().toLowerCase().trim().equals("hora menor que"))) {
            sql = sql + " < '" + criterio.getTexto() + "'";
        } else if ((criterio.getOperador().toLowerCase().trim().equals("data maior que"))
                || (criterio.getOperador().toLowerCase().trim().equals("hora maior que"))) {
            sql = sql + " > '" + criterio.getTexto() + "'";
        } else if ((criterio.getOperador().toLowerCase().trim().equals("data menor ou igual"))
                || (criterio.getOperador().toLowerCase().trim().equals("hora menor ou igual"))) {
            sql = sql + " <= '" + criterio.getTexto() + "'";
        } else if ((criterio.getOperador().toLowerCase().trim().equals("data maior ou igual"))
                || (criterio.getOperador().toLowerCase().trim().equals("hora maior ou igual"))) {
            sql = sql + " >= '" + criterio.getTexto() + "'";
        } else if (criterio.getOperador().toLowerCase().trim().equals("contendo")) {
            sql = sql + " LIKE '%" + criterio.getTexto().toUpperCase() + "%'";
        } else if (criterio.getOperador().toLowerCase().trim().equals("iniciando com")) {
            sql = sql + " LIKE '" + criterio.getTexto().toUpperCase() + "%'";
        } else if (criterio.getOperador().toLowerCase().trim().equals("terminando com")) {
            sql = sql + " LIKE '%" + criterio.getTexto().toUpperCase() + "'";
        } else if (criterio.getOperador().toLowerCase().trim().equals("diferente de")) {
            sql = sql + " <> '" + criterio.getTexto().toUpperCase() + "'";
        } else {
            FacesUtils.addInfoMessage("Erro no operador da consulta! Informe ao administrador do sistema.");
            return;
        }
        sql = sql + ")"; //+ " ORDER BY c.id DESC";
        limparSqlsConsulta();
        setSqlConsulta(sql);
        setSqlClausulaTodosRegistros(tabelas + " " + sql.substring(sql.indexOf("WHERE", 14) - 1, sql.lastIndexOf(")") + 1));
        setPaginaAtual(0);
        atualizaTabela();
    }

    public void processarOperador(ValueChangeEvent vce) {

        if (vce.getNewValue() != null) {
            setSomOperador(vce.getNewValue().toString());
            if ((getSomOperador().equals("igual a")) || (getSomOperador().equals("contendo"))
                    || (getSomOperador().equals("diferente de")) || (getSomOperador().equals("iniciando com")) || (getSomOperador().equals("terminando com"))) {
                setConversor(null);
            } else if ((getSomOperador().equals("maior que")) || (getSomOperador().equals("menor que")) || (getSomOperador().equals("maior ou igual")) || (getSomOperador().equals("menor ou igual"))) {
                setConversor(new NumberConverter());
            } else if ((getSomOperador().equals("data maior que")) || (getSomOperador().equals("data igual a")) || (getSomOperador().equals("data menor que")) || (getSomOperador().equals("data maior ou igual")) || (getSomOperador().equals("data menor ou igual"))) {
                DateTimeConverter sqlTime = new DateTimeConverter();
                sqlTime.setPattern("yyyy-MM-dd");
                setConversor(sqlTime);
            } else if ((getSomOperador().equals("hora maior que")) || (getSomOperador().equals("hora igual a")) || (getSomOperador().equals("hora menor que")) || (getSomOperador().equals("hora menor ou igual")) || (getSomOperador().equals("hora maior ou igual"))) {
                DateTimeConverter sqlTime = new DateTimeConverter();
                sqlTime.setPattern("HH:mm");
                setConversor(sqlTime);
            }
        }

    }
    private boolean renderizaConfirmaExclusao = false;

    public boolean isRenderizaConfirmaExclusao() {
        return renderizaConfirmaExclusao;
    }

    public void setRenderizaConfirmaExclusao(boolean renderizaConfirmaExclusao) {
        this.renderizaConfirmaExclusao = renderizaConfirmaExclusao;
    }

    public void cancelarExclusao(ActionEvent event) {
        System.out.println("cancelar exclusão");
        renderizaConfirmaExclusao = false;
    }

    public void abrirConfirmacaoDeExclusao(ActionEvent event) {
        System.out.println("abrirConfirmacaoDeExclusao");
//        BaseController controler = ((MetodosBotoes) FacesUtils.getManagedBean("botoes")).getControllerPagina();
        if ((getObjeto() != null) && (((InterfaceEntidades) getObjeto()).getId() != null)) {
            System.out.println("renderizaConfirmaExclusao");
            renderizaConfirmaExclusao = true;
        }
    }

    public void confirmarExclusao(ActionEvent event) {
        renderizaConfirmaExclusao = false;
        excluir(event);
    }

    public void setCollection(Collection c) {
    }

    public Collection getCollection() {
        return null;
    }

    public void setCollection1(Collection c1) {
    }

    public Collection getCollection1() {
        return null;
    }
    private DataModel dataModelTabela = null;

    public DataModel getDataModelTabela() {
        return dataModelTabela = new ListDataModel((List) getCollection());
    }

    public void setDataModelTabela(DataModel dataModelTabela) {
        this.dataModelTabela = dataModelTabela;
    }
    InterfaceEntidades itemSelecionado;

    public InterfaceEntidades getItemSelecionado() {
        return itemSelecionado;
    }

    public void setItemSelecionado(InterfaceEntidades itemSelecionado) {
        this.itemSelecionado = itemSelecionado;
    }

    public void adicionarItem(ActionEvent event) {
        if (getCollection() == null) {
            setCollection(new ArrayList());
        }
        if (itemSelecionado != null) {
            if (getCollection().contains(itemSelecionado)) {
                if (event.getComponent() != null) {
                    FacesUtils.addInfoMessage(event.getComponent().getClientId(), "Registro Duplicado.");
                }
                return;
            } else {
                getCollection().add(itemSelecionado);

            }
        }
    }

    public void excluirItem(ActionEvent event) {
        if ((getCollection() != null)) {
            InterfaceEntidades interfaceEntidades = (InterfaceEntidades) dataModelTabela.getRowData();
            if (getCollection().contains(interfaceEntidades)) {
                getCollection().remove(interfaceEntidades);
            }
        }
    }
    private DataModel dataModelTabela1 = null;

    public DataModel getDataModelTabela1() {
        return dataModelTabela1 = new ListDataModel((List) getCollection1());
    }

    public void setDataModelTabela1(DataModel dataModelTabela1) {
        this.dataModelTabela1 = dataModelTabela1;
    }
    InterfaceEntidades itemSelecionado1;

    public InterfaceEntidades getItemSelecionado1() {
        return itemSelecionado1;
    }

    public void setItemSelecionado1(InterfaceEntidades itemSelecionado1) {
        this.itemSelecionado1 = itemSelecionado1;
    }

    public void adicionarItem1(ActionEvent event) {
        if (getCollection1() == null) {
            setCollection1(new ArrayList());
        }
        if (itemSelecionado1 != null) {
            if (getCollection1().contains(itemSelecionado1)) {
                if (event.getComponent() != null) {
                    FacesUtils.addInfoMessage(event.getComponent().getClientId(), "Registro Duplicado.");
                }
                return;
            } else {
                getCollection1().add(itemSelecionado1);

            }
        }
    }

    public void excluirItem1(ActionEvent event) {
        if ((getCollection1() != null)) {
            InterfaceEntidades interfaceEntidades = (InterfaceEntidades) dataModelTabela1.getRowData();
            if (getCollection1().contains(interfaceEntidades)) {
                getCollection1().remove(interfaceEntidades);
            }
        }
    }

    public String consultaDefinida(String sql) {
        return null;
    }

    public void consultaEspecifica(ActionEvent event) {
        String sql = null;
        String tabelas = "";
        sql = consultaDefinida(sql);
        if ((sql != null)) {
            limparSqlsConsulta();
            setSqlConsulta(sql);
            setSqlClausulaTodosRegistros(tabelas + " " + sql.substring(sql.indexOf("WHERE", 14) - 1, sql.lastIndexOf(")") + 1));
            setPaginaAtual(0);
            atualizaTabela();
        }
    }
    
}
